<!DOCTYPE html>
<meta charset=utf-8>
<title>序列化Python对象 - 深入Python 3</title>
<!--[if IE]><script src=j/html5.js></script><![endif]-->
<link rel=stylesheet href="dip3.css">
<style>
body{counter-reset:h1 13}
</style>
<link rel=stylesheet media='only screen and (max-device-width: 480px)' href="http://woodpecker.org.cn/diveintopython3/mobile.css">
<link rel=stylesheet media=print href="http://woodpecker.org.cn/diveintopython3/print.css">
<meta name=viewport content='initial-scale=1.0'>
<form action=http://www.google.com/cse><div><input type=hidden name=cx value=014021643941856155761:l5eihuescdw><input type=hidden name=ie value=UTF-8>&nbsp;<input type=search name=q size=25 placeholder="powered by Google&trade;">&nbsp;<input type=submit name=root value=Search></div></form>
<p>您在这里: <a href="index.html">主页</a> <span class=u>&#8227;</span> <a href="table-of-contents.html#serializing">深入Python 3</a> <span class=u>&#8227;</span>
<p id=level>难度等级: <span class=u title=advanced>&#x2666;&#x2666;&#x2666;&#x2666;&#x2662;</span>
<h1>序列化Python对象</h1>
<blockquote class=q>
<p><span class=u>&#x275D;</span> Every Saturday since we&#8217;ve lived in this apartment, I have awakened at 6:15, poured myself a bowl of cereal, added<br>a quarter-cup of 2% milk, sat on <strong>this</strong> end of <strong>this</strong> couch, turned on BBC America, and watched Doctor Who. <span class=u>&#x275E;</span><br>&mdash; Sheldon, <a href='http://en.wikiquote.org/wiki/The_Big_Bang_Theory#The_Dumpling_Paradox_.5B1.07.5D'>The Big Bang Theory</a>
</blockquote>
<p id=toc>&nbsp;
<h2 id=divingin>深入</h2>
<p><dfn>序列化</dfn>的概念很简单。内存里面有一个数据结构，你希望将它保存下来，重用，或者发送给其他人。你会怎么做？嗯, 这取决于你想要怎么保存，怎么重用，发送给谁。很多游戏允许你在退出的时候保存进度，然后你再次启动的时候回到上次退出的地方。(实际上, 很多非游戏程序也会这么干。) 在这个情况下, 一个捕获了当前进度的数据结构需要在你退出的时候保存到磁盘上，接着在你重新启动的时候从磁盘上加载进来。这个数据只会被创建它的程序使用，不会发送到网络上，也不会被其它程序读取。因此，互操作的问题被限制在保证新版本的程序能够读取以前版本的程序创建的数据。

<p>在这种情况下，<code>pickle</code> 模块是理想的。它是Python标准库的一部分, 所以它总是可用的。它很快; 它的大部分同Python解释器本身一样是用C写的。 它可以存储任意复杂的Python数据结构。

<p>什么东西能用<code>pickle</code>模块存储?

<ul>
<li>所有Python支持的 <a href="native-datatypes.html">原生类型</a> : 布尔, 整数, 浮点数, 复数, 字符串, <code>bytes</code>(字节串)对象, 字节数组, 以及 <code>None</code>.
<li>由任何原生类型组成的列表，元组，字典和集合。
<li>由任何原生类型组成的列表，元组，字典和集合组成的列表，元组，字典和集合(可以一直嵌套下去，直至<a title='sys.getrecursionlimit()' href=http://docs.python.org/3.1/library/sys.html#sys.getrecursionlimit>Python支持的最大递归层数</a>).
<li>函数，类，和类的实例(带警告)。
</ul>

<p>如果这还不够用，<code>pickle</code>模块也是可扩展的。如果你对可扩展性有兴趣，请查看本章最后的<a href="serializing.html#furtherreading">进一步阅读</a>小节中的链接。

<h3 id=administrivia>本章例子的快速笔记</h3>

<p>本章会使用两个Python Shell来讲故事。本章的例子都是一个单独的故事的一部分。当我演示<code>pickle</code> 和 <code>json</code> 模块时，你会被要求在两个Python Shell中来回切换。

<p>为了让事情简单一点，打开Python Shell 并定义下面的变量:

<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>shell = 1</kbd></pre>

<p>保持该窗口打开。 现在打开另一个Python Shell 并定义下面下面的变量:

<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>shell = 2</kbd></pre>

<p>贯穿整个章节, 在每个例子中我会使用<code>shell</code>变量来标识使用的是哪个Python Shell。

<p class=a>&#x2042;

<h2 id=dump>保存数据到 Pickle 文件</h2>

<p><code>pickle</code>模块的工作对象是数据结构。让我们来创建一个：

<pre class=screen>
<a><samp class=p>>>> </samp><kbd class=pp>shell</kbd>                                                                                              <span class=u>&#x2460;</span></a>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry = {}</kbd>                                                                                         <span class=u>&#x2461;</span></a>
<samp class=p>>>> </samp><kbd class=pp>entry['title'] = 'Dive into history, 2009 edition'</kbd>
<samp class=p>>>> </samp><kbd class=pp>entry['article_link'] = 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition'</kbd>
<samp class=p>>>> </samp><kbd class=pp>entry['comments_link'] = None</kbd>
<samp class=p>>>> </samp><kbd class=pp>entry['internal_id'] = b'\xDE\xD5\xB4\xF8'</kbd>
<samp class=p>>>> </samp><kbd class=pp>entry['tags'] = ('diveintopython', 'docbook', 'html')</kbd>
<samp class=p>>>> </samp><kbd class=pp>entry['published'] = True</kbd>
<samp class=p>>>> </samp><kbd class=pp>import time</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>entry['published_date'] = time.strptime('Fri Mar 27 22:20:42 2009')</kbd>                                <span class=u>&#x2462;</span></a>
<samp class=p>>>> </samp><kbd class=pp>entry['published_date']</kbd>
<samp class=pp>time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1)</samp></pre>
<ol>
<li>在Python Shell #1 里面。
<li>想法是建立一个Python字典来表示一些有用的东西，比如<a href="xml.html#xml-structure">一个Atom 供稿的entry</a>。但是为了炫耀一下<code>pickle</code>模块我也想保证里面包含了多种不同的数据类型。不需要太关心这些值。
<li><code>time</code> 模块包含一个表示时间点(精确到1毫秒)的数据结构(<code>time_struct</code>)以及操作时间结构的函数。<code>strptime()</code>函数接受一个格式化过的字符串并将其转化成一个<code>time_struct</code>。这个字符串使用的是默认格式，但你可以通过格式化代码来控制它。查看<a href=http://docs.python.org/3.1/library/time.html><code>time</code>模块</a>来获得更多细节。
</ol>

<p>这是一个很帅的Python 字典。让我们把它保存到文件。

<pre class=screen>
<a><samp class=p>>>> </samp><kbd class=pp>shell</kbd>                                    <span class=u>&#x2460;</span></a>
<samp class=pp>1</samp>
<samp class=p>>>> </samp><kbd class=pp>import pickle</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>with open('entry.pickle', 'wb') as f:</kbd>    <span class=u>&#x2461;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    pickle.dump(entry, f)</kbd>                <span class=u>&#x2462;</span></a>
<samp class=p>... </samp></pre>
<ol>
<li>仍然在Python Shell #1 中。
<li>使用<code>open()</code> 函数来打开一个文件。设置文件模式为<code>'wb'</code>来以<a href="files.html#binary">二进制</a>写模式打开文件。把它放入<a href="files.html#with"><code>with</code> 语句</a>中来保证在你完成的时候文件自动被关闭。
<li><code>pickle</code>模块中的<code>dump()</code>函数接受一个可序列化的Python 数据结构, 使用最新版本的pickle协议将其序列化为一个二进制的，Python特定的格式， 并且保存到一个打开的文件里。
</ol>

<p>最后一句话很重要。

<ul>
<li><code>pickle</code>模块接受一个Python数据结构并将其保存的一个文件。
<li>要做到这样，它使用一个被称为&#8220;pickle协议&#8221;的东西<i>序列化</i>该数据结构。
<li>pickle 协议是Python特定的，没有任何跨语言兼容的保证。你很可能不能使用Perl, <abbr>PHP</abbr>, Java, 或者其他语言来对你刚刚创建的<code>entry.pickle</code>文件做任何有用的事情。
<li>并非所有的Python数据结构都可以通过<code>pickle</code>模块序列化。随着新的数据类型被加入到Python语言中，pickle协议已经被修改过很多次了，但是它还是有一些限制。
<li>由于这些变化，不同版本的Python的兼容性也没有保证。新的版本的Python支持旧的序列化格式，但是旧版本的Python不支持新的格式(因为它们不支持新的数据类型)。
<li>除非你指定，<code>pickle</code>模块中的函数将使用最新版本的pickle协议。这保证了你对可以被序列化的数据类型有最大的灵活度，但这也意味着生成的文件不能被不支持新版pickle协议的旧版本的Python读取。
<li>最新版本的pickle协议是二进制格式的。请确认使用<a href="files.html#binary">二进制模式</a>来打开你的pickle文件,否则当你写入的时候数据会被损坏。
</ul>

<p class=a>&#x2042;

<h2 id=load>从Pickle文件读取数据</h2>

<p>现在切换到你的第二个Python Shell&nbsp;&mdash;&nbsp;<i>即</i>不是你创建<code>entry</code>字典的那个。

<pre class=screen>
<a><samp class=p>>>> </samp><kbd class=pp>shell</kbd>                                    <span class=u>&#x2460;</span></a>
<samp class=pp>2</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry</kbd>                                    <span class=u>&#x2461;</span></a>
<samp class=traceback>Traceback (most recent call last):
  File "&lt;stdin>", line 1, in &lt;module>
NameError: name 'entry' is not defined</samp>
<samp class=p>>>> </samp><kbd class=pp>import pickle</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>with open('entry.pickle', 'rb') as f:</kbd>    <span class=u>&#x2462;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    entry = pickle.load(f)</kbd>               <span class=u>&#x2463;</span></a>
<samp class=p>... </samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry</kbd>                                    <span class=u>&#x2464;</span></a>
<samp class=pp>{'comments_link': None,
 'internal_id': b'\xDE\xD5\xB4\xF8',
 'title': 'Dive into history, 2009 edition',
 'tags': ('diveintopython', 'docbook', 'html'),
 'article_link':
 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition',
 'published_date': time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1),
 'published': True}</samp></pre>
<ol>
<li>这是Python Shell #2.
<li>这里没有<var>entry</var> 变量被定义过。你在Python Shell #1 中定义了<var>entry</var>变量, 但是那是另一个拥有自己状态的完全不同的环境。
<li>打开你在Python Shell #1中创建的<code>entry.pickle</code>文件。<code>pickle</code>模块使用二进制数据格式，所以你总是应该使用二进制模式打开pickle文件。
<li><code>pickle.load()</code>函数接受一个<a href="files.html#file-objects">流对象</a>, 从流中读取序列化后的数据，创建一个新的Python对象，在新的Python对象中重建被序列化的数据，然后返回新建的Python对象。
<li>现在<var>entry</var>变量是一个键和值看起来都很熟悉的字典。
</ol>

<p><code>pickle.dump() / pickle.load()</code>循环的结果是一个和原始数据结构等同的新的数据结构。 

<pre class=screen>
<a><samp class=p>>>> </samp><kbd class=pp>shell</kbd>                                    <span class=u>&#x2460;</span></a>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>with open('entry.pickle', 'rb') as f:</kbd>    <span class=u>&#x2461;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    entry2 = pickle.load(f)</kbd>              <span class=u>&#x2462;</span></a>
<samp class=p>... </samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry2 == entry</kbd>                          <span class=u>&#x2463;</span></a>
<samp class=pp>True</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry2 is entry</kbd>                          <span class=u>&#x2463;</span></a>
<samp class=pp>False</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry2['tags']</kbd>                           <span class=u>&#x2465;</span></a>
<samp class=pp>('diveintopython', 'docbook', 'html')</samp>
<samp class=p>>>> </samp><kbd class=pp>entry2['internal_id']</kbd>
<samp class=pp>b'\xDE\xD5\xB4\xF8'</samp></pre>
<ol>
<li>切换回Python Shell #1。
<li>打开<code>entry.pickle</code>文件。
<li>将序列化后的数据装载到一个新的变量, <var>entry2</var>。
<li>Python 确认两个字典, <var>entry</var> 和 <var>entry2</var> 是相等的。在这个shell里, 你从零开始构造了<var>entry</var>, 从一个空字典开始然后手工给各个键赋值。你序列化了这个字典并将其保存在<code>entry.pickle</code>文件中。现在你从文件中读取序列化后的数据并创建了原始数据结构的一个完美复制品。
<li>相等和相同是不一样的。我说的是你创建了原始数据结构的一个<em>完美复制品</em>, 这没错。但它仅仅是一个复制品。
<li>我要指出<code>'tags'</code>键对应的值是一个元组，而<code>'internal_id'</code>键对应的值是一个<code>bytes</code>对象。原因在这章的后面就会清楚了。
</ol>

<p class=a>&#x2042;

<h2 id=dumps>不使用文件来进行序列化</h2>

<p>前一节中的例子展示了如果将一个Python对象序列化到磁盘文件。但如果你不想或不需要文件呢？你也可以序列化到一个内存中的<code>bytes</code>对象。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>b = pickle.dumps(entry)</kbd>     <span class=u>&#x2460;</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>type(b)</kbd>                     <span class=u>&#x2461;</span></a>
<samp class=pp>&lt;class 'bytes'></samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry3 = pickle.loads(b)</kbd>    <span class=u>&#x2462;</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>entry3 == entry</kbd>             <span class=u>&#x2463;</span></a>
<samp class=pp>True</samp></pre>
<ol>
<li><code>pickle.dumps()</code>函数(注意函数名最后的<code>'s'</code>)执行和<code>pickle.dump()</code>函数相同的序列化。取代接受流对象并将序列化后的数据保存到磁盘文件，这个函数简单的返回序列化的数据。
<li>由于pickle协议使用一个二进制数据格式，所以<code>pickle.dumps()</code>函数返回<code>bytes</code>对象。
<li><code>pickle.loads()</code>函数(再一次, 注意函数名最后的<code>'s'</code>) 执行和<code>pickle.load()</code>函数一样的反序列化。取代接受一个流对象并去文件读取序列化后的数据，它接受包含序列化后的数据的<code>bytes</code>对象, 比如<code>pickle.dumps()</code>函数返回的对象。
<li>最终结果是一样的: 原始字典的完美复制。
</ol>

<p class=a>&#x2042;

<h2 id=protocol-versions>字节串和字符串又一次抬起了它们丑陋的头。</h2>

<p>pickle协议已经存在好多年了，它随着Python本身的成熟也不断成熟。现在存在<a href=http://docs.python.org/3.1/library/pickle.html#data-stream-format>四个不同版本</a> 的pickle协议。

<ul>
<li>Python 1.x 有两个pickle协议，一个基于文本的格式(&#8220;版本 0&#8221;) 以及一个二进制格式(&#8220;版本 1&#8221;).
<li>Python 2.3 引入了一个新的pickle协议(&#8220;版本 2&#8221;) 来处理Python 类对象的新功能。它是一个二进制格式。
<li>Python 3.0 引入了另一个pickle 协议 (&#8220;版本 3&#8221;) ，显式的支持<code>bytes</code> 对象和字节数组。它是一个二进制格式。
</ul>

<p>你看, <a href="strings.html#byte-arrays">字节串和字符串的区别</a>又一次抬起了它们丑陋的头。 (如果你觉得惊奇，你肯定开小差了。) 在实践中这意味着, 尽管Python 3 可以读取版本 2 的pickle 协议生成的数据, Python 2 不能读取版本 3的协议生成的数据.

<p class=a>&#x2042;

<h2 id=debugging>调试Pickle 文件</h2>

<p>pickle 协议是长什么样的呢？让我们离开Python Shell一会会，来看一下我们创建的<code>entry.pickle</code>文件。

<pre class=screen>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>ls -l entry.pickle</kbd>
<samp>-rw-r--r-- 1 you  you  358 Aug  3 13:34 entry.pickle</samp>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>cat entry.pickle</kbd>
<samp>comments_linkqNXtagsqXdiveintopythonqXdocbookqXhtmlq?qX publishedq?
XlinkXJhttp://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition
q   Xpublished_dateq
ctime
struct_time
?qRqXtitleqXDive into history, 2009 editionqu.</samp></pre>

<p>这不是很有用。你可以看见字符串，但是其他数据类型显示为不可打印的(或者至少是不可读的)字符。域之间没有明显的分隔符(比如跳格符或空格)。你肯定不希望来调试这样一个格式。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<samp class=p>>>> </samp><kbd class=pp>import pickletools</kbd>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.pickle', 'rb') as f:</kbd>
<samp class=p>... </samp><kbd class=pp>    pickletools.dis(f)</kbd>
<samp>    0: \x80 PROTO      3
    2: }    EMPTY_DICT
    3: q    BINPUT     0
    5: (    MARK
    6: X        BINUNICODE 'published_date'
   25: q        BINPUT     1
   27: c        GLOBAL     'time struct_time'
   45: q        BINPUT     2
   47: (        MARK
   48: M            BININT2    2009
   51: K            BININT1    3
   53: K            BININT1    27
   55: K            BININT1    22
   57: K            BININT1    20
   59: K            BININT1    42
   61: K            BININT1    4
   63: K            BININT1    86
   65: J            BININT     -1
   70: t            TUPLE      (MARK at 47)
   71: q        BINPUT     3
   73: }        EMPTY_DICT
   74: q        BINPUT     4
   76: \x86     TUPLE2
   77: q        BINPUT     5
   79: R        REDUCE
   80: q        BINPUT     6
   82: X        BINUNICODE 'comments_link'
  100: q        BINPUT     7
  102: N        NONE
  103: X        BINUNICODE 'internal_id'
  119: q        BINPUT     8
  121: C        SHORT_BINBYTES '脼脮麓酶'
  127: q        BINPUT     9
  129: X        BINUNICODE 'tags'
  138: q        BINPUT     10
  140: X        BINUNICODE 'diveintopython'
  159: q        BINPUT     11
  161: X        BINUNICODE 'docbook'
  173: q        BINPUT     12
  175: X        BINUNICODE 'html'
  184: q        BINPUT     13
  186: \x87     TUPLE3
  187: q        BINPUT     14
  189: X        BINUNICODE 'title'
  199: q        BINPUT     15
  201: X        BINUNICODE 'Dive into history, 2009 edition'
  237: q        BINPUT     16
  239: X        BINUNICODE 'article_link'
  256: q        BINPUT     17
  258: X        BINUNICODE 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition'
  337: q        BINPUT     18
  339: X        BINUNICODE 'published'
  353: q        BINPUT     19
  355: \x88     NEWTRUE
  356: u        SETITEMS   (MARK at 5)
  357: .    STOP
<mark>highest protocol among opcodes = 3</mark></samp></pre>

<p>这个反汇编中最有趣的信息是最后一行, 因为它包含了文件保存时使用的pickle协议的版本号。在pickle协议里面没有明确的版本标志。为了确定保存pickle文件时使用的协议版本，你需要查看序列化后的数据的标记(&#8220;opcodes&#8221;)并且使用硬编码的哪个版本的协议引入了哪些标记的知识(来确定版本号)。<code>pickle.dis()</code>函数正是这么干的，并且它在反汇编的输出的最后一行打印出结果。下面是一个不打印，仅仅返回版本号的函数:

<p class=d>[<a href="examples/pickleversion.py">下载 <code>pickleversion.py</code></a>]
<pre class=pp><code>import pickletools

def protocol_version(file_object):
    maxproto = -1
    for opcode, arg, pos in pickletools.genops(file_object):
        maxproto = max(maxproto, opcode.proto)
    return maxproto</code></pre>

<p>实际使用它:</p>

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import pickleversion</kbd>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.pickle', 'rb') as f:</kbd>
<samp class=p>... </samp><kbd class=pp>    v = pickleversion.protocol_version(f)</kbd>
<samp class=p>>>> </samp><kbd class=pp>v</kbd>
<samp class=pp>3</samp></pre>

<p class=a>&#x2042;

<h2 id=json>序列化Python对象以供其它语言读取</h2>

<p><code>pickle</code>模块使用的数据格式是Python特定的。它没有做任何兼容其它编程语言的努力。如果跨语言兼容是你的需求之一，你得去寻找其它的序列化格式。一个这样的格式是<a href=http://json.org/><abbr>JSON</abbr></a>。 &#8220;<abbr>JSON</abbr>&#8221; 代表 &#8220;JavaScript Object Notation,&#8221; 但是不要让名字糊弄你。&nbsp;&mdash;&nbsp;<abbr>JSON</abbr> 是被设计为跨语言使用的。

<p>Python 3 在标准库中包含了一个 <code>json</code>模块。同 <code>pickle</code>模块类似,  <code>json</code>模块包含一些函数，可以序列化数据结构，保存序列化后的数据至磁盘，从磁盘上读取序列化后的数据，将数据反序列化成新的Pythone对象。但两者也有一些很重要的区别。 首先, <abbr>JSON</abbr>数据格式是基于文本的, 不是二进制的。<a href=http://www.ietf.org/rfc/rfc4627.txt>RFC 4627</a> 定义了<abbr>JSON</abbr>格式以及怎样将各种类型的数据编码成文本。比如，一个布尔值要么存储为5个字符的字符串<code>'false'</code>，要么存储为4个字符的字符串 <code>'true'</code>。 所有的<abbr>JSON</abbr>值都是大小写敏感的。

<p>第二，由于是文本格式, 存在空白(whitespaces)的问题。 <abbr>JSON</abbr> 允许在值之间有任意数目的空白(空格, 跳格, 回车，换行)。空白是&#8220;无关紧要的&#8221;，这意味着<abbr>JSON</abbr>编码器可以按它们的喜好添加任意多或任意少的空白, 而<abbr>JSON</abbr>解码器被要求忽略值之间的任意空白。这允许你&#8220;美观的打印（pretty-print）&#8221; 你的 <abbr>JSON</abbr> 数据, 通过不同的缩进层次嵌套值，这样你就可以在标准浏览器或文本编辑器中阅读它。Python 的 <code>json</code> 模块有在编码时执行美观打印（pretty-printing）的选项。

<p>第三, 字符编码的问题是长期存在的。<abbr>JSON</abbr> 用纯文本编码数据, 但是你知道, <a href="strings.html">&#8220;不存在纯文本这种东西。&#8221;</a> <abbr>JSON</abbr>必须以Unicode 编码(UTF-32, UTF-16, 或者默认的, <abbr>UTF-8</abbr>)方式存储, <a href=http://www.ietf.org/rfc/rfc4627.txt>RFC 4627的第3节</a> 定义了如何区分使用的是哪种编码。

<p class=a>&#x2042;

<h2 id=json-dump>将数据保存至 <abbr>JSON</abbr> 文件</h2>

<p><abbr>JSON</abbr> 看起来非常像你在Javascript中手工定义的数据结构。这不是意外; 实际上你可以使用JavaScript 的<code>eval()</code>函数来&#8220;解码&#8221; <abbr>JSON</abbr>序列化过的数据。(通常的<a href="advanced-iterators.html#eval">对非信任输入的警告</a> 也适用, 但关键点是<abbr>JSON</abbr> <em>是</em> 合法的JavaScript。) 因此, 你可能已经熟悉<abbr>JSON</abbr>了。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>basic_entry = {}</kbd>                                           <span class=u>&#x2460;</span></a>
<samp class=p>>>> </samp><kbd class=pp>basic_entry['id'] = 256</kbd>
<samp class=p>>>> </samp><kbd class=pp>basic_entry['title'] = 'Dive into history, 2009 edition'</kbd>
<samp class=p>>>> </samp><kbd class=pp>basic_entry['tags'] = ('diveintopython', 'docbook', 'html')</kbd>
<samp class=p>>>> </samp><kbd class=pp>basic_entry['published'] = True</kbd>
<samp class=p>>>> </samp><kbd class=pp>basic_entry['comments_link'] = None</kbd>
<samp class=p>>>> </samp><kbd class=pp>import json</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>with open('basic.json', mode='w', encoding='utf-8') as f:</kbd>  <span class=u>&#x2461;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    json.dump(basic_entry, f)</kbd>                              <span class=u>&#x2462;</span></a></pre>
<ol>
<li>我们将创建一个新的数据结构，而不是重用现存的<var>entry</var>数据结构。在这章的后面, 我们将会看见当我们试图用<abbr>JSON</abbr>编码更复杂的数据结构的时候会发生什么。
<li><abbr>JSON</abbr> 是一个基于文本的格式， 这意味你可以以文本模式打开文件，并给定一个字符编码。用<abbr>UTF-8</abbr>总是没错的。
<li>同<code>pickle</code>模块一样, <code>json</code> 模块定义了<code>dump()</code>函数，它接受一个Python 数据结构和一个可写的流对象。<code>dump()</code> 函数将Python数据结构序列化并写入到流对象中。在<code>with</code>语句内工作保证当我们完成的时候正确的关闭文件。
</ol>

<p>那么生成的<abbr>JSON</abbr>序列化数据是什么样的呢？

<pre class=screen>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>cat basic.json</kbd>
<samp>{"published": true, "tags": ["diveintopython", "docbook", "html"], "comments_link": null,
"id": 256, "title": "Dive into history, 2009 edition"}</samp></pre>

<p>这肯定<a href="serializing.html#debugging">比pickle 文件更可读</a>。然而 <abbr>JSON</abbr> 的值之间可以包含任意数目的空把, 并且<code>json</code>模块提供了一个方便的途径来利用这一点生成更可读的<abbr>JSON</abbr>文件。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<samp class=p>>>> </samp><kbd class=pp>with open('basic-pretty.json', mode='w', encoding='utf-8') as f:</kbd>
<a><samp class=p>... </samp><kbd class=pp>    json.dump(basic_entry, f, <mark style="display:inline">indent=2</mark>)</kbd>                            <span class=u>&#x2460;</span></a></pre>
<ol>
<li>如果你给<code>json.dump()</code>函数传入<var>indent</var>参数, 它以文件变大为代价使生成的<abbr>JSON</abbr>文件更可读。<var>indent</var> 参数是一个整数。0 意味着&#8220;每个值单独一行。&#8221; 大于0的数字意味着&#8220;每个值单独一行并且使用这个数目的空格来缩进嵌套的数据结构。&#8221;
</ol>

<p>这是结果:

<pre class=screen>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>cat basic-pretty.json</kbd>
<samp>{
  "published": true, 
  "tags": [
    "diveintopython", 
    "docbook", 
    "html"
  ], 
  "comments_link": null, 
  "id": 256, 
  "title": "Dive into history, 2009 edition"
}</samp></pre>

<p class=a>&#x2042;

<h2 id=json-types>将Python数据类型映射到<abbr>JSON</abbr></h2>

<p>由于<abbr>JSON</abbr> 不是Python特定的，对应到Python的数据类型的时候有很多不匹配。有一些仅仅是名字不同，但是有两个Python数据类型完全缺少。看看你能能把它们指出来:

<table>
<tr><th>笔记
<th>JSON
<th>Python 3
<tr><th>
<td>object
<td><a href="native-datatypes.html#dictionaries">dictionary</a>
<tr><th>
<td>array
<td><a href="native-datatypes.html#lists">list</a>
<tr><th>
<td>string
<td><a href="strings.html#divingin">string</a>
<tr><th>
<td>integer
<td><a href="native-datatypes.html#numbers">integer</a>
<tr><th>
<td>real number
<td><a href="native-datatypes.html#numbers">float</a>
<tr><th>*
<td><code>true</code>
<td><a href="native-datatypes.html#booleans"><code>True</code></a>
<tr><th>*
<td><code>false</code>
<td><a href="native-datatypes.html#booleans"><code>False</code></a>
<tr><th>*
<td><code>null</code>
<td><code><a href="native-datatypes.html#none">None</a></code>
<tfoot><tr><td colspan=3>* 所有的 <abbr>JSON</abbr> 值都是大小写敏感的。
</table>

<p>注意到什么被遗漏了吗？元组和 <i class=baa>&amp;</i> 字节串（bytes）! <abbr>JSON</abbr> 有数组类型, <code>json</code> 模块将其映射到Python的列表, 但是它没有一个单独的类型对应 &#8220;冻结数组(frozen arrays)&#8221; (元组)。而且尽管 <abbr>JSON</abbr> 非常好的支持字符串，但是它没有对<code>bytes</code> 对象或字节数组的支持。

<p class=a>&#x2042;

<h2 id=json-unknown-types>序列化<abbr>JSON</abbr>不支持的数据类型</h2>

<p>即使<abbr>JSON</abbr>没有内建的字节流支持, 并不意味着你不能序列化<code>bytes</code>对象。<code>json</code>模块提供了编解码未知数据类型的扩展接口。(&#8220;未知&#8221;的意思是&#8820;<abbr>JSON</abbr>没有定义&#8221;。很显然<code>json</code> 模块认识字节数组, 但是它被<abbr>JSON</abbr>规范的限制束缚住了。) 如果你希望编码字节串或者其它<abbr>JSON</abbr>没有原生支持的数据类型，你需要给这些类型提供定制的编码和解码器。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry</kbd>                                                 <span class=u>&#x2460;</span></a>
<samp class=pp>{'comments_link': None,
 'internal_id': b'\xDE\xD5\xB4\xF8',
 'title': 'Dive into history, 2009 edition',
 'tags': ('diveintopython', 'docbook', 'html'),
 'article_link': 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition',
 'published_date': time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1),
 'published': True}</samp>
<samp class=p>>>> </samp><kbd class=pp>import json</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'w', encoding='utf-8') as f:</kbd>  <span class=u>&#x2461;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    json.dump(entry, f)</kbd>                               <span class=u>&#x2462;</span></a>
<samp class=p>... </samp>
<samp class=traceback>Traceback (most recent call last):
  File "&lt;stdin>", line 5, in &lt;module>
  File "C:\Python31\lib\json\__init__.py", line 178, in dump
    for chunk in iterable:
  File "C:\Python31\lib\json\encoder.py", line 408, in _iterencode
    for chunk in _iterencode_dict(o, _current_indent_level):
  File "C:\Python31\lib\json\encoder.py", line 382, in _iterencode_dict
    for chunk in chunks:
  File "C:\Python31\lib\json\encoder.py", line 416, in _iterencode
    o = _default(o)
  File "C:\Python31\lib\json\encoder.py", line 170, in default
    raise TypeError(repr(o) + " is not JSON serializable")
<mark>TypeError: b'\xDE\xD5\xB4\xF8' is not JSON serializable</mark></samp></pre>
<ol>
<li>好的, 是时间再看看<var>entry</var> 数据结构了。它包含了所有的东西: 布尔值，<code>None</code>值，字符串，字符串元组, <code>bytes</code>对象, 以及<code>time</code>结构体。
<li>我知道我已经说过了，但是这值得再重复一次：<abbr>JSON</abbr> 是一个基于文本的格式。总是应使用<abbr>UTF-8</abbr>字符编码以文本模式打开<abbr>JSON</abbr>文件。
<li>嗯，<em>这</em>可不好。发生什么了？
</ol>

<p>情况是这样的: <code>json.dump()</code> 函数试图序列化<code>bytes</code>对象 <code>b'\xDE\xD5\xB4\xF8'</code>，但是它失败了，原因是<abbr>JSON</abbr> 不支持<code>bytes</code>对象。然而, 如果保存字节串对你来说很重要，你可以定义自己的&#8220;迷你序列化格式。&#8221;

<p class=d>[<a href="examples/customserializer.py">download <code>customserializer.py</code></a>]
<pre class=pp><code>
<a>def to_json(python_object):                                             <span class=u>&#x2460;</span></a>
<a>    if isinstance(python_object, bytes):                                <span class=u>&#x2461;</span></a>
<a>        return {'__class__': 'bytes',
                '__value__': list(python_object)}                       <span class=u>&#x2462;</span></a>
<a>    raise TypeError(repr(python_object) + ' is not JSON serializable')  <span class=u>&#x2463;</span></a></code></pre>
<ol>
<li>为了给一个<abbr>JSON</abbr>没有原生支持的数据类型定义你自己的&#8220;迷你序列化格式&#8221;, 只要定义一个接受一个Python对象为参数的函数。这个对象将会是<code>json.dump()</code>函数无法自己序列化的实际对象&nbsp;&mdash;&nbsp;这个例子里是<code>bytes</code> 对象 <code>b'\xDE\xD5\xB4\xF8'</code>。
<li>你的自定义序列化函数应该检查<code>json.dump()</code>函数传给它的对象的类型。当你的函数只序列化一个类型的时候这不是必须的，但是它使你的函数的覆盖的内容清楚明白，并且在你需要序列化更多类型的时候更容易扩展。
<li>在这个例子里面, 我将<code>bytes</code> 对象转换成字典。<code>__class__</code> 键持有原始的数据类型(以字符串的形式, <code>'bytes'</code>), 而 <code>__value__</code> 键持有实际的数据。当然它不能是<code>bytes</code>对象; 大体的想法是将其转换成某些可以被<abbr>JSON</abbr>序列化的东西! <code>bytes</code>对象就是一个范围在0&ndash;255的整数的序列。 我们可以使用<code>list()</code> 函数将<code>bytes</code>对象转换成整数列表。所以<code>b'\xDE\xD5\xB4\xF8'</code> 变成 <code>[222, 213, 180, 248]</code>. (算一下! 这是对的! 16进制的字节 <code>\xDE</code> 是十进制的 222, <code>\xD5</code> 是 213, 以此类推。)
<li>这一行很重要。你序列化的数据结构可能包含<abbr>JSON</abbr>内建的可序列化类型和你的定制序列化器支持的类型之外的东西。在这种情况下，你的定制序列化器抛出一个<code>TypeError</code>，那样<code>json.dump()</code> 函数就可以知道你的定制序列化函数不认识该类型。
</ol>

<p>就这么多；你不需要其它的东西。特别是, 这个定制序列化函数<em>返回Python字典</em>，不是字符串。你不是自己做所有序列化到<abbr>JSON</abbr>的工作; 你仅仅在做转换成被支持的类型那部分工作。<code>json.dump()</code> 函数做剩下的事情。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<a><samp class=p>>>> </samp><kbd class=pp>import customserializer</kbd>                                                             <span class=u>&#x2460;</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'w', encoding='utf-8') as f:</kbd>                                <span class=u>&#x2461;</span></a>
<a><samp class=p>... </samp><kbd class=pp>    json.dump(entry, f, <mark style="display:inline">default=customserializer.to_json</mark>)</kbd>                           <span class=u>&#x2462;</span></a>
<samp class=p>... </samp>
<samp class=traceback>Traceback (most recent call last):
  File "&lt;stdin>", line 9, in &lt;module>
    json.dump(entry, f, default=customserializer.to_json)
  File "C:\Python31\lib\json\__init__.py", line 178, in dump
    for chunk in iterable:
  File "C:\Python31\lib\json\encoder.py", line 408, in _iterencode
    for chunk in _iterencode_dict(o, _current_indent_level):
  File "C:\Python31\lib\json\encoder.py", line 382, in _iterencode_dict
    for chunk in chunks:
  File "C:\Python31\lib\json\encoder.py", line 416, in _iterencode
    o = _default(o)
  File "/Users/pilgrim/diveintopython3/examples/customserializer.py", line 12, in to_json
<a>    raise TypeError(repr(python_object) + ' is not JSON serializable')                     <span class=u>&#x2463;</span></a>
TypeError: time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1) is not JSON serializable</samp></pre>
<ol>
<li><code>customserializer</code> 模块是你在前一个例子中定义<code>to_json()</code>函数的地方。
<li>文本模式, <abbr>UTF-8</abbr> 编码, yadda yadda。(你很可能会忘记这一点! 我就忘记过好几次! 事情一切正常直到它失败的时刻, 而它的失败很令人瞩目。)
<li>这是重点: 为了将定制转换函数钩子嵌入<code>json.dump()</code>函数, 只要将你的函数以<var>default</var>参数传入<code>json.dump()</code>函数。(万岁, <a href="your-first-python-program.html#everythingisanobject">Python里一切皆对象</a>!)
<li>好吧, 实际上还是不能工作。但是看一下异常。<code>json.dump()</code> 函数不再抱怨无法序列化<code>bytes</code>对象了。现在它在抱怨另一个完全不同的对象:  <code>time.struct_time</code> 对象。
</ol>

<p>尽管得到另一个不同的异常看起来不是什么进步, 但它确实是个进步! 再调整一下就可以解决这个问题。

<pre class=pp><code>
import time

def to_json(python_object):
<a>    if isinstance(python_object, time.struct_time):          <span class=u>&#x2460;</span></a>
<a>        return {'__class__': 'time.asctime',
                '__value__': time.asctime(python_object)}    <span class=u>&#x2461;</span></a>
    if isinstance(python_object, bytes):
        return {'__class__': 'bytes',
                '__value__': list(python_object)}
    raise TypeError(repr(python_object) + ' is not JSON serializable')</code></pre>
<ol>
<li>在现存的<code>customserializer.to_json()</code>函数里面, 我们加入了Python 对象 (<code>json.dump()</code> 处理不了的那些) 是不是 <code>time.struct_time</code>的判断。
<li>如果是的，我们做一些同处理<code>bytes</code>对象时类似的事情来转换: 将<code>time.struct_time</code> 结构转化成一个只包含<abbr>JSON</abbr>可序列化值的字典。在这个例子里, 最简单的将日期时间转换成<abbr>JSON</abbr>可序列化值的方法是使用<code>time.asctime()</code>函数将其转换成字符串。<code>time.asctime()</code> 函数将难看的<code>time.struct_time</code> 转换成字符串 <code>'Fri Mar 27 22:20:42 2009'</code>。
</ol>

<p>有了两个定制的转换, 整个<var>entry</var> 数据结构序列化到<abbr>JSON</abbr>应该没有进一步的问题了。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'w', encoding='utf-8') as f:</kbd>
<samp class=p>... </samp><kbd class=pp>    json.dump(entry, f, default=customserializer.to_json)</kbd>
<samp class=p>... </samp></pre>

<pre class=screen>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>ls -l example.json</kbd>
<samp>-rw-r--r-- 1 you  you  391 Aug  3 13:34 entry.json</samp>
<samp class=p>you@localhost:~/diveintopython3/examples$ </samp><kbd>cat example.json</kbd>
<samp>{"published_date": {"__class__": "time.asctime", "__value__": "Fri Mar 27 22:20:42 2009"},
"comments_link": null, "internal_id": {"__class__": "bytes", "__value__": [222, 213, 180, 248]},
"tags": ["diveintopython", "docbook", "html"], "title": "Dive into history, 2009 edition",
"article_link": "http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition",
"published": true}</samp></pre>

<p class=a>&#x2042;

<h2 id=json-load>从<abbr>JSON</abbr>文件加载数据</h2>

<p>类似<code>pickle</code> 模块，<code>json</code>模块有一个<code>load()</code>函数接受一个流对象，从中读取 <abbr>JSON</abbr>编码过的数据, 并且创建该<abbr>JSON</abbr>数据结构的Python对象的镜像。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>2</samp>
<a><samp class=p>>>> </samp><kbd class=pp>del entry</kbd>                                             <span class=u>&#x2460;</span></a>
<samp class=p>>>> </samp><kbd class=pp>entry</kbd>
<samp class=traceback>Traceback (most recent call last):
  File "&lt;stdin>", line 1, in &lt;module>
NameError: name 'entry' is not defined</samp>
<samp class=p>>>> </samp><kbd class=pp>import json</kbd>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'r', encoding='utf-8') as f:</kbd>
<a><samp class=p>... </samp><kbd class=pp>    entry = json.load(f)</kbd>                              <span class=u>&#x2461;</span></a>
<samp class=p>... </samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry</kbd>                                                 <span class=u>&#x2462;</span></a>
<samp class=pp>{'comments_link': None,
 'internal_id': {'__class__': 'bytes', '__value__': [222, 213, 180, 248]},
 'title': 'Dive into history, 2009 edition',
 'tags': ['diveintopython', 'docbook', 'html'],
 'article_link': 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition',
 'published_date': {'__class__': 'time.asctime', '__value__': 'Fri Mar 27 22:20:42 2009'},
 'published': True}</samp></pre>
<ol>
<li>为了演示目的，切换到Python Shell #2 并且删除在这一章前面使用<code>pickle</code>模块创建的<var>entry</var>数据结构。
<li>最简单的情况下，<code>json.load()</code>函数同<code>pickle.load()</code>函数的结果一模一样。你传入一个流对象，它返回一个新的Python对象。
<li>有好消息也有坏消息。好消息先来: <code>json.load()</code> 函数成功的读取了你在Python Shell #1中创建的<code>entry.json</code>文件并且生成了一个包含那些数据的新的Python对象。接着是坏消息: 它没有重建原始的 <var>entry</var> 数据结构。<code>'internal_id'</code> 和 <code>'published_date'</code> 这两个值被重建为字典&nbsp;&mdash;&nbsp;具体来说, 你在<code>to_json()</code>转换函数中使用<abbr>JSON</abbr>兼容的值创建的字典。
</ol>

<p><code>json.load()</code> 并不知道你可能传给<code>json.dump()</code>的任何转换函数的任何信息。你需要的是<code>to_json()</code>函数的逆函数&nbsp;&mdash;&nbsp;一个接受定制转换出的<abbr>JSON</abbr> 对象并将其转换回原始的Python数据类型。

<pre class=pp><code># add this to customserializer.py
<a>def from_json(json_object):                                   <span class=u>&#x2460;</span></a>
<a>    if '__class__' in json_object:                            <span class=u>&#x2461;</span></a>
        if json_object['__class__'] == 'time.asctime':
<a>            return time.strptime(json_object['__value__'])    <span class=u>&#x2462;</span></a>
        if json_object['__class__'] == 'bytes':
<a>            return bytes(json_object['__value__'])            <span class=u>&#x2463;</span></a>
    return json_object</code></pre>
<ol>
<li>这函数也同样接受一个参数返回一个值。但是参数不是字符串，而是一个Python对象&nbsp;&mdash;&nbsp;反序列化一个<abbr>JSON</abbr>编码的字符串为Python的结果。
<li>你只需要检查这个对象是否包含<code>to_json()</code>函数创建的<code>'__class__'</code>键。如果是的，<code>'__class__'</code>键对应的值将告诉你如何将值解码成原来的Python数据类型。
<li>为了解码由<code>time.asctime()</code>函数返回的字符串，你要使用<code>time.strptime()</code>函数。这个函数接受一个格式化过的时间字符串(格式可以自定义，但默认值同<code>time.asctime()</code>函数的默认值相同) 并且返回<code>time.struct_time</code>.
<li>为了将整数列表转换回<code>bytes</code> 对象, 你可以使用 <code>bytes()</code> 函数。
</ol>

<p>就是这样; <code>to_json()</code>函数处理了两种数据类型，现在这两个数据类型也在<code>from_json()</code>函数里面处理了。下面是结果:

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>2</samp>
<samp class=p>>>> </samp><kbd class=pp>import customserializer</kbd>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'r', encoding='utf-8') as f:</kbd>
<a><samp class=p>... </samp><kbd class=pp>    entry = json.load(f, object_hook=customserializer.from_json)</kbd>  <span class=u>&#x2460;</span></a>
<samp class=p>... </samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry</kbd>                                                             <span class=u>&#x2461;</span></a>
<samp class=pp>{'comments_link': None,
 'internal_id': b'\xDE\xD5\xB4\xF8',
 'title': 'Dive into history, 2009 edition',
 'tags': ['diveintopython', 'docbook', 'html'],
 'article_link': 'http://diveintomark.org/archives/2009/03/27/dive-into-history-2009-edition',
 'published_date': time.struct_time(tm_year=2009, tm_mon=3, tm_mday=27, tm_hour=22, tm_min=20, tm_sec=42, tm_wday=4, tm_yday=86, tm_isdst=-1),
 'published': True}</samp></pre>
<ol>
<li>为了将<code>from_json()</code>函数嵌入到反序列化过程中，把它作为<var>object_hook</var> 参数传入到<code>json.load()</code>函数中。接受函数作为参数的函数; 真方便!
<li><var>entry</var> 数据结构现在有一个值为<code>bytes</code>对象的<code>'internal_id'</code>键。它也包含一个<code>'published_date'</code>键，其值为<code>time.struct_time</code>对象。
</ol>

<p>然而，还有最后一个缺陷。

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>shell</kbd>
<samp class=pp>1</samp>
<samp class=p>>>> </samp><kbd class=pp>import customserializer</kbd>
<samp class=p>>>> </samp><kbd class=pp>with open('entry.json', 'r', encoding='utf-8') as f:</kbd>
<samp class=p>... </samp><kbd class=pp>    entry2 = json.load(f, object_hook=customserializer.from_json)</kbd>
<samp class=p>... </samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry2 == entry</kbd>                                                    <span class=u>&#x2460;</span></a>
<samp class=pp>False</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry['tags']</kbd>                                                      <span class=u>&#x2461;</span></a>
<samp class=pp>('diveintopython', 'docbook', 'html')</samp>
<a><samp class=p>>>> </samp><kbd class=pp>entry2['tags']</kbd>                                                     <span class=u>&#x2462;</span></a>
<samp class=pp>['diveintopython', 'docbook', 'html']</samp></pre>
<ol>
<li>即使在序列化过程中加入了<code>to_json()</code>钩子函数, 也在反序列化过程中加入<code>from_json()</code>钩子函数, 我们仍然没有重新创建原始数据结构的完美复制品。为什么没有？
<li>在原始的<var>entry</var> 数据结构中, <code>'tags'</code>键的值为一个三个字符串组成的元组。
<li>但是重现创建的<var>entry2</var> 数据结构中, <code>'tags'</code> 键的值是一个三个字符串组成的<em>列表</em>。<abbr>JSON</abbr> 并不区分元组和列表；它只有一个类似列表的数据类型，数组，并且<code>json</code>模块在序列化过程中会安静的将元组和列表两个都转换成<abbr>JSON</abbr> 数组。大多数情况下，你可以忽略元组和列表的区别，但是在使用<code>json</code> 模块时应记得有这么一回使。
</ol>

<h2 id=furtherreading>进一步阅读</h2>

<blockquote class=note>
<p><span class=u>&#x261E;</span>很多关于<code>pickle</code>模块的文章提到了<code>cPickle</code>。在Python 2中, <code>pickle</code> 模块有两个实现, 一个由纯Python写的而另一个用C写的(但仍然可以在Python中调用)。在Python 3中, <a href="porting-code-to-python-3-with-2to3.html#othermodules">这两个模块已经合并</a>, 所以你总是简单的<code>import pickle</code>就可以。你可能会发现这些文章很有用，但是你应该忽略已过时的关于的<code>cPickle</code>的信息.
</blockquote>

<p>使用<code>pickle</code>模块打包:

<ul>
<li><a href=http://docs.python.org/3.1/library/pickle.html><code>pickle</code> module</a>
<li><a href=http://www.doughellmann.com/PyMOTW/pickle/><code>pickle</code> and <code>cPickle</code>&nbsp;&mdash;&nbsp;Python object serialization</a>
<li><a href=http://wiki.python.org/moin/UsingPickle>Using <code>pickle</code></a>
<li><a href=http://www.ibm.com/developerworks/library/l-pypers.html>Python persistence management</a>
</ul>

<p>使用<abbr>JSON</abbr> 和 <code>json</code> 模块:

<ul>
<li><a href=http://www.doughellmann.com/PyMOTW/json/><code>json</code>&nbsp;&mdash;&nbsp;JavaScript Object Notation Serializer</a>
<li><a href=http://blog.quaternio.net/2009/07/16/json-encoding-and-decoding-with-custom-objects-in-python/>JSON encoding and ecoding with custom objects in Python</a>
</ul>

<p>扩展打包:

<ul>
<li><a href=http://docs.python.org/3.1/library/pickle.html#pickling-class-instances>Pickling class instances</a>
<li><a href=http://docs.python.org/3.1/library/pickle.html#persistence-of-external-objects>Persistence of external objects</a>
<li><a href=http://docs.python.org/3.1/library/pickle.html#handling-stateful-objects>Handling stateful objects</a>
</ul>

<p class=v><a rel=prev href="xml.html" title='back to &#8220;XML&#8221;'><span class=u>&#x261C;</span></a> <a rel=next href="http-web-services.html" title='onward to &#8220;HTTP Web Services&#8221;'><span class=u>&#x261E;</span></a>
<p class=c>&copy; 2001&ndash;9 <a href="about.html">Mark Pilgrim</a>
<script src="j/jquery.js"></script>
<script src="j/prettify.js"></script>
<script src="j/dip3.js"></script>
